#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include "lock_loop.h"
#include "key.h"
#include "rte.h"
#include "app_ehbl_uart.h"
#include "tim_out.h"
#include "ledbuz_rte.h"

static lock_loop_data lock_data;

typedef struct
{
    Rt_result (*loop_app)(void);
} AppServer_E_Fun;

static AppServer_E_Fun Ehbl_loop[LOOP_NOT_MAX] =
    {
        {loop_initunlock},
        {loop_unlock_lock},
        {loop_ex_eol}};

/**
 * @brief 用于处理锁循环的UART回调函数
 *
 * 此函数在接收到特定的UART命令后，会更新内部的锁定数据状态。
 *
 * @param cmd 接收到的UART命令的16位编码
 * @param data 通过UART接收到的数据数组，数组中包含具体的锁定操作数据
 */
void lock_loop_uartcb(uint16_t cmd, uint8_t data[])
{
    // 当前阶段串口发送成功标志为OK，即表示之前的数据发送已完成
    if (NO_SENT_OR_RECEIVED == lock_data.Rflag && OK_SENT_OR_RECEIVED == lock_data.Tflag)
    {
        // 清除当前阶段的串口发送成功标志，准备接收新的命令
        lock_data.Tflag = NO_SENT_OR_RECEIVED;
        // 设置当前阶段的串口接收成功标志
        lock_data.Rflag = OK_SENT_OR_RECEIVED;
        // 更新接收到的命令编码
        lock_data.Rx.sig.CMD = cmd;
        // 将接收到的数据拷贝到锁数据结构的相应位置
        memcpy(&lock_data.Rx.L_data[0], &data[0], 4);
    }
}

/**
 * 初始化锁循环状态
 *
 * 该函数用于初始化一个全局的锁状态数据结构，将锁设置为未锁定状态，并准备好等待线程来获取锁。
 * 初始化包括设置开始键稳定状态、锁计数、测试状态和锁的状态。
 * 参数: 无
 * 返回值: 无
 */
void lock_loop_init(void)
{
    // 初始化锁的状态数据
    lock_data.start_keyStableState = true; // 设置开始键稳定状态为true，表示系统准备就绪
    // lock_data.cycle_3s = false;                                              // 初始化3秒循环状态为false，表示当前不在3秒循环中
    // lock_data.time_3s = 0;                                                   // 初始化3秒计时器为0
    lock_data.count = 0;                                   // 初始化锁计数为0，表示没有线程持有锁
    lock_data.t_st = LOOP_NOT_MAX;                         // 设置测试状态为未测试，表示锁尚未进行测试
    lock_data.q_st = LOCK_QUER_MAX;                        // 设置为查询状态为最大值，表示尚未进行查询
    lock_data.locked = IS_UNLOCK;                          // 将锁的状态设置为未锁定，表示目前锁未被持有，等待线程来获取
    lock_data.query_locked = IS_LOCK;                      // 将查询锁的状态设置为锁定
    memset(lock_data.Tx.L_data, 0, sizeof(LOCK_UART_NUM)); // 清空传输数据缓冲区
    lock_data.Tflag = NO_SENT_OR_RECEIVED;                 // 初始化发送标志为未发送或接收
    memset(lock_data.Rx.L_data, 0, sizeof(LOCK_UART_NUM)); // 清空接收数据缓冲区
    lock_data.Rflag = NO_SENT_OR_RECEIVED;                 // 初始化接收标志为未发送或接收
    memset(lock_data.e_sta, TEST_WAIT, LOOP_NOT_MAX);      // 清空各阶段具体结果情况
    lock_data.LOOP_results = TEST_WAIT;                    // 初始化流程是否走完
    // RTE_GPIO_PIN_SET_LEVEL(GPIOC, OverCurCtr_O_LL_PC13_Pin, GPIO_PIN_RESET); // 设置过流控制输出锁低电平，实现产品下电控制
    // key_init();                                                              // 复位按键初始化
    // Uart4_init();                                                            // 串口4的初始化，用于锁的通信
    // TimeTick_Init();                                                         // 时间滴答初始化，用于计时和时间管理
    // Led_buzz_init();                                                         // LED和蜂鸣器初始化，用于状态指示和提醒
    // LCD_init();/*LCD串口通讯协议初始化*/
}

/*
 * 函数名称: loop_detection
 * 功能描述: 检测传入的命令和版本信息是否与串口接收到的信息一致。
 * 参数列表:
 *    cmd - 输入参数，表示待检测的命令编号。
 *    VERSION - 输入参数，表示待检测的版本号。
 * 返回值:
 *    Rt_result - 表示检测结果的枚举类型，可能的值包括TEST_WAIT, TEST_OK和TEST_FAIL。
 * 备注:
 *    无
 */
Rt_result loop_detection(uint16_t cmd, uint32_t VERSION)
{
    Rt_result result = TEST_WAIT; // 初始化检测结果为等待状态

    // 清除接收标志
    lock_data.Rflag = NO_SENT_OR_RECEIVED;

    // 检测传入的命令和版本信息是否与串口接收到的信息一致
    if (cmd == lock_data.Rx.sig.CMD && VERSION == lock_data.Rx.sig.DATA)
    {
        result = TEST_OK; // 信息一致，检测通过
    }
    else
    {
        result = TEST_FAIL; // 信息不一致，检测失败
        RTE_UART7_LCD_SHOW(EHBL_TEST, REASON_FOR_LOOP_FAILURE, LOOP_RSP_ERR);
        HAL_Delay(120);
        RTE_UART7_LCD_SHOW(EHBL_TEST, LOOP_SUCCESS_OR_FAILURE, TEST_FAIL);
        HAL_Delay(120);
    }

    return result; // 返回检测结果
}

/**
 * 请求锁定或解锁
 *
 * 本函数用于通过串口发送锁定或解锁请求，并处理请求的响应或超时情况。
 * 请求只会被发送一次，直到收到响应或超时才会进行下一步处理。
 *
 * @param Req_cmd 请求命令的编码，用于指定是锁定还是解锁请求。
 * @param Req_data 请求数据的编码，具体含义根据Req_cmd来确定。
 * @param Rsp_cmd 预期响应命令的编码，用于后续响应的匹配和验证。
 * @param Rsp_data 预期响应数据的编码，用于后续响应的匹配和验证。
 * @param locked 一个标志，指示当前锁的状态（锁定或解锁）。
 *               如果为锁定状态，则函数尝试解锁；
 *               如果为解锁状态，则函数尝试锁定。
 * @return 返回请求的结果，可能包括等待响应、请求成功或请求失败等状态。
 */
Rt_result Req_lock(uint16_t Req_cmd, uint32_t Req_data, uint16_t Rsp_cmd, uint32_t Rsp_data, Is_locked locked)
{
    static uint32_t Record_send_time = 0; /* 记录发送请求的时间戳，用于超时判断 */
    Rt_result result = TEST_WAIT;         /* 请求结果的初始状态为等待测试结果 */
    /* 标志位判断，确保请求只发送一次 */
    if (true == lock_data.start_keyStableState)
    {
        lock_data.start_keyStableState = false;    /* 防止重复发送请求 */
        lock_data.Tx.sig.CMD = Req_cmd;            /* 设置发送的命令 */
        lock_data.Tx.sig.DATA = Req_data;          /* 设置发送的数据 */
        RTE_EHBL_UART_TRANSMIT(Req_cmd, Req_data); /* 通过串口发送锁定/解锁请求 */
        lock_data.Tflag = OK_SENT_OR_RECEIVED;     /* 设置发送标志 */
        lock_data.Rflag = NO_SENT_OR_RECEIVED;     /* 清除接收标志 */
        Record_send_time = RTE_GET_TIMER();        /* 记录发送请求的开始时间 */
        if (EHBL_DURING_TEST == Get_EHBL_testing_phase())
        {
            /* 根据锁定标志更新锁的状态 */
            if (IS_LOCK == locked)
            {
                RTE_UART7_LCD_SHOW(EHBL_TEST, LOCK_FRONT_STATE, IS_UNLOCK);
                HAL_Delay(120);
                RTE_UART7_LCD_SHOW(EHBL_TEST, LOCK_CURRENT_STATE, IS_LOCK);
            }
            else if (IS_UNLOCK == locked)
            {
                RTE_UART7_LCD_SHOW(EHBL_TEST, LOCK_FRONT_STATE, IS_LOCK);
                HAL_Delay(120);
                RTE_UART7_LCD_SHOW(EHBL_TEST, LOCK_CURRENT_STATE, IS_UNLOCK);
                HAL_Delay(120);
                lock_data.count++; /* 如果是解锁请求，增加计数器 */
                RTE_UART7_LCD_SHOW(EHBL_TEST, LOOP_NUMBER, lock_data.count);
                // lock_data.cycle_3s = true;    /* 标记本次3秒周期完成 */
            }
        }
    }
    /* 处理串口接收回复或超时的情况 */
    else if (yes_timeout == RTE_TIMEOUT_JUDGMENT(Record_send_time, LOCK_DLY))
    {
        /* 根据接收标志判断并处理响应 */
        if (OK_SENT_OR_RECEIVED == lock_data.Rflag)
        {
            result = loop_detection(Rsp_cmd, Rsp_data); /* 检测并处理响应结果 */
        }
        else
        {
            result = TEST_FAIL; /* 如果没有收到预期的响应，则视为请求失败 */
            RTE_UART7_LCD_SHOW(EHBL_TEST, REASON_FOR_LOOP_FAILURE, LOOP_TIMEOUT_ERR);
            HAL_Delay(120);
            RTE_UART7_LCD_SHOW(EHBL_TEST, LOOP_SUCCESS_OR_FAILURE, TEST_FAIL);
            HAL_Delay(120);
        }
        if (EHBL_DURING_TEST == Get_EHBL_testing_phase())
        {
            /* 根据锁定标志更新锁的状态 */
            if (IS_LOCK == locked)
            {
                lock_data.locked = IS_LOCK; /* 更新为锁定状态 */
            }
            else if (IS_UNLOCK == locked)
            {
                lock_data.locked = IS_UNLOCK; /* 更新为解锁状态 */
            }
        }
        // result = TEST_OK; /* 超时情况下的测试结果，此处根据实际需求可能有不同处理 */
        lock_data.start_keyStableState = true; /* 重置发送请求的标志，准备下一次请求 */
    }
    return result; /* 返回请求的结果 */
}

/**
 * 函数名称：count_determine
 * 功能描述：检查锁的数量是否与预设的锁数据计数相等，如果相等，则重新初始化锁循环。
 * 参数列表：
 *    - result：实验结果，用于判断是否需要重新初始化锁循环。
 * 返回值：无
 */
Rt_result count_determine(Rt_result result)
{
    if (TEST_WAIT == result || TEST_FAIL == result)
    {
        return result;
    }
    if (LOCK_NUM == lock_data.count)
    {
        RTE_UART7_LCD_SHOW(EHBL_TEST, LOOP_SUCCESS_OR_FAILURE, TEST_OK);
    }
    else
    {
        /*继续完成该阶段*/
        result = TEST_WAIT;
    }
    return result;
}

/**
 * @brief 实现一个3秒周期的计时循环管理
 *
 * 该函数不接受参数，也不返回任何值。它主要用于内部状态管理，特别是用于处理
 * 需要每隔3秒重新启动一次的循环逻辑。
 *
 * 主要步骤包括检查当前时间是否超出了3秒周期的界限，如果是，则重置周期计时器
 * 并开启一个新的3秒循环。
 */
void cycle_3s_time(void)
{
    // 检查是否到达了3秒的超时点
    if (yes_timeout == RTE_TIMEOUT_JUDGMENT(lock_data.time_3s, TIME_3S))
    {
        lock_data.time_3s = RTE_GET_TIMER(); /* 更新3秒周期的开始时间 */
        lock_data.cycle_3s = false;          /* 重置循环标志，开始新的3秒循环 */
    }
}

Rt_result Determine_lock_status(Rt_result result)
{
    if (IS_WAIT == lock_data.query_locked) /* 锁在闭锁和解锁情况下都已经检查过一次了，后续直接退出 */
    {
        return result;
    }

    if (TEST_OK == result)
    {
        if (IS_LOCK == lock_data.locked)
        {
            lock_data.query_locked = IS_LOCK; /* 查询当前是否为闭锁状态 */
        }
        else if (IS_UNLOCK == lock_data.locked)
        {
            lock_data.query_locked = IS_UNLOCK; /* 查询当前是否为解锁状态 */
        }
        lock_data.locked = IS_WAIT; /*让锁变化查询状态*/
        result = TEST_WAIT;
    }

    if (IS_WAIT == lock_data.locked) /*当前有第一次解锁或者闭锁完成，等待查询对应状态*/
    {
        if (IS_LOCK == lock_data.query_locked) /*当前查询状态为闭锁*/
        {
            result = EHBL_universal_Req_Rsp(QUERY_CMD, QUERY_CMD, EHBL_REQUEST_DATA, QUERY_UNLOCK_DATA);
            if (TEST_WAIT != result)
            {
                lock_data.locked = IS_LOCK;
            }
        }
        else if (IS_UNLOCK == lock_data.query_locked) /*当前查询状态为解锁*/
        {
            result = EHBL_universal_Req_Rsp(QUERY_CMD, QUERY_CMD, EHBL_REQUEST_DATA, QUERY_LOCK_DATA);
            if (TEST_WAIT != result)
            {
                lock_data.query_locked = IS_WAIT; /* 查询状态结束 */
                lock_data.locked = IS_UNLOCK;
            }
        }
    }

    return result;
}

/**
 * @brief 尝试锁定或解锁
 *
 * 该函数用于根据当前锁的状态，请求锁定或解锁。如果锁是未锁定状态，则尝试锁定；如果锁是锁定状态，则尝试解锁。
 * 不论请求成功或失败，函数都会返回一个操作结果。
 *
 * @return Rt_result 操作结果。可能包含锁定或解锁的成功或失败信息。
 */
Rt_result lock_unlock(void)
{
    Rt_result result = TEST_WAIT;
    // 判断是否需要进行锁定或解锁操作
    if (IS_UNLOCK == lock_data.locked)
    {
        // 请求锁定
        result = Req_lock(LOCK_TEST_CMD, EHBL_LOCK_REQUEST_DATA, LOCK_TEST_CMD, EHBL_RSP_DATA_OK, IS_LOCK);
    }
    else if (IS_LOCK == lock_data.locked)
    {
        // 请求解锁
        result = Req_lock(UNLOCK_TEST_CMD, EHBL_UNLOCK_REQUEST_DATA, UNLOCK_TEST_CMD, EHBL_RSP_DATA_OK, IS_UNLOCK);
    }

    result = Determine_lock_status(result); // 检查锁的状态，并根据状态进行后续操作

    return result;
}

/**
 * @brief 初始化并解锁
 *
 * 该函数用于初始化一个操作，并尝试对其进行解锁。具体操作包括初始化结果变量为特定值，
 * 然后调用Req_lock函数进行请求锁定操作，期待得到特定的响应结果。
 *
 * @return Rt_result 函数执行的结果。返回值的具体含义根据上下文而定，一般表示操作的成功或失败。
 */
Rt_result loop_initunlock(void)
{
    Rt_result result = TEST_WAIT; // 初始化结果变量为TEST_WAIT，等待状态
    if (LOCK_QUER_MAX == lock_data.q_st)
    {
        lock_data.q_st = QUERY_IN_PROGRESS;
        RTE_UART7_LCD_SHOW(EHBL_TEST, LOOP_NUMBER, 0x00000000);
    }
    if (QUERY_IN_PROGRESS == lock_data.q_st)
    {
        result = EHBL_universal_Req_Rsp(QUERY_CMD, QUERY_CMD, EHBL_REQUEST_DATA, QUERY_LOCK_DATA);
        if (TEST_FAIL == result) /*当前不为解锁状态*/
        {
            lock_data.q_st = RESETTING_IN_PROGRESS;
        }
    }
    if (RESETTING_IN_PROGRESS == lock_data.q_st)
    {
        // 尝试使用指定的命令和数据进行解锁操作，期望得到成功的响应
        result = Req_lock(UNLOCK_TEST_CMD, EHBL_UNLOCK_REQUEST_DATA, UNLOCK_TEST_CMD, EHBL_RSP_DATA_OK, IS_WAIT);
    }
    return result; // 返回操作结果
}

/**
 * @brief 尝试进行锁定或解锁操作，并根据操作结果进行后续处理。
 *
 * 该函数首先初始化结果变量为TEST_WAIT，然后调用lock_unlock()函数进行锁定或解锁操作。
 * 原计划中有周期性3秒计时操作，但在当前代码版本中被注释。
 * 最后，根据操作结果调用count_determine()函数进行进一步的判断和处理。
 *
 * @return Rt_result 操作的结果，具体含义依赖于实现。
 */
Rt_result loop_unlock_lock(void)
{
    Rt_result result = TEST_WAIT; // 初始化结果变量为TEST_WAIT
    result = lock_unlock();       // 请求锁定或解锁

    // 根据结果进行计数判断，决定是否继续循环或终止
    result = count_determine(result);
    return result;
}
/**
 * @brief 这个函数用于执行结束EOL（End Of Line）流程的特定操作。
 *
 * 该函数不需要任何参数。
 * @return Rt_result 返回操作的结果状态码。可能的返回值包括TEST_WAIT和TEST_OK等。
 */
Rt_result loop_ex_eol(void)
{
    Rt_result result = TEST_WAIT; // 初始化结果变量为TEST_WAIT

    // 向系统发送退出EOL流程的请求，并等待响应
    result = EHBL_universal_Req_Rsp(EHBL_QUIT_EOL_CMD, EHBL_QUIT_EOL_CMD, EHBL_REQUEST_DATA, EHBL_RSP_DATA_OK);

    // 如果结果不等于TEST_WAIT，则将LOOP_results设置为TEST_OK
    if (TEST_WAIT != result)
    {
        lock_data.LOOP_results = TEST_OK;
    }
    return result;
}

/**
 * 在LCD上显示循环阶段的结果
 *
 * 本函数根据当前的循环阶段，将特定的测试结果展示在LCD上。
 *
 * @param result 测试结果，类型为Rt_result，包含了测试的详细结果信息。
 * @param stage 当前的循环阶段，类型为lock_loop_status，决定了要显示的结果信息和方式。
 */
void Loop_Stage_result_LCDshow(Rt_result result, lock_loop_status stage)
{
    switch (stage) // 根据当前循环阶段选择要显示的信息
    {
    case LOOP_INIT:
        // 在初始化阶段显示解锁成功或失败的信息
        RTE_UART7_LCD_SHOW(EHBL_LOOP_TEST, LOOP_INIT_UNLOCK, result);
        break;
    case LOOP_DURING_TEST:
        // 在测试进行中显示测试成功或失败的信息
        RTE_UART7_LCD_SHOW(EHBL_LOOP_TEST, LOOP_SUCCESS_OR_FAILURE, result);
        break;
    case LOOP_EX_EOL_MOD:
        // 在结束循环模块时显示退出信息
        RTE_UART7_LCD_SHOW(EHBL_LOOP_TEST, LOCK_EHBL_QUIT_EOL, result);
        break;
    default:
        // 对于未处理的阶段，不显示任何信息
        break;
    }
}

/*
 * 函数介绍: 修改LOOP测试阶段
 * 参数:
 * 返回值: {*}
 * 备注:
 */
void Modify_LOOP_testing_phase(lock_loop_status phase)
{
    lock_data.t_st = phase;
}

/**
 * 对循环阶段的结果进行判断，并根据结果更新阶段状态及显示
 *
 * @param result 测试结果，类型为Rt_result
 * @param stage 当前阶段状态，类型为lock_loop_status
 * 该函数不返回任何值。
 */
void Loop_Stage_result_judgment(Rt_result result, lock_loop_status stage)
{
    // 如果测试结果为等待状态，则直接返回，不进行后续操作
    if (TEST_WAIT == result)
    {
        return;
    }
    // 将阶段状态递增，准备进行下一个阶段
    stage += 1;
    // 在LCD上显示测试结果，并更新锁数据中的测试结果
    Loop_Stage_result_LCDshow(result, lock_data.t_st);
    lock_data.e_sta[lock_data.t_st] = result;
    // 修改EHBL的测试阶段为下一个阶段
    Modify_LOOP_testing_phase(stage);
}

/**
 * @brief 处理循环测试的结果并返回最终的测试结果。
 *
 * 该函数首先检查测试流程是否已完成，如果已完成，则将测试结果设置为TEST_OK，
 * 并清零测试完成标志。接着，该函数会遍历循环测试中的各个状态，将它们的结果
 * 与最终结果进行或运算。最后，根据最终结果的不同，显示不同的测试结果信息。
 *
 * @return Rt_result 最终的测试结果。可能的值包括TEST_OK表示测试成功，TEST_FAIL
 * 表示测试失败，以及其他可能的测试结果代码。
 */
Rt_result loop_results(void)
{
    uint8_t i = 0;
    Rt_result result = TEST_WAIT; /* 初始化测试结果值为等待状态 */

    /* 检查测试流程是否已经完成 */
    if (TEST_OK == lock_data.LOOP_results)
    {
        result = TEST_OK;
        lock_data.LOOP_results = TEST_WAIT; /* 重置测试完成标志 */

        /* 遍历并累积每个循环的状态结果 */
        for (i = 0; i < LOOP_NOT_MAX; i++)
        {
            result |= lock_data.e_sta[i];
        }
    }

    /* 根据最终的测试结果，显示相应的信息 */
    if (TEST_OK == result) /* 如果测试成功 */
    {
        RTE_UART7_LCD_SHOW(EHBL_LOOP_TEST, TEST_RESULT, result);
    }
    else if (TEST_FAIL == result) /* 如果测试失败 */
    {
        RTE_UART7_LCD_SHOW(EHBL_LOOP_TEST, TEST_RESULT, result);
    }
    return result;
}

/**
 * @brief 处理循环测试的结果，并根据结果进行相应的操作。
 *
 * 该函数首先检查传入的测试结果，如果结果指示需要等待，则直接返回。
 * 如果结果为成功，则在GPIOC的OUT7_PC6_Pin上设置高电平。
 * 如果结果不为成功，则在GPIOD的OUT8_PD15_Pin上设置高电平，并标记循环测试整体为失败。
 *
 * @param result 测试结果，类型为Rt_result。
 */
void loop_results_relevant(Rt_result result)
{
    // 检查是否需要等待
    if (TEST_WAIT == result)
    {
        return;
    }
    lock_loop_init(); // 初始化循环锁定

    // 根据测试结果进行相应的GPIO操作
    if (TEST_OK == result)
    {
        RTE_GPIO_PIN_SET_LEVEL(GPIOC, OUT7_PC6_Pin, GPIO_PIN_SET); // 设置成功信号
    }
    else
    {
        RTE_GPIO_PIN_SET_LEVEL(GPIOD, OUT8_PD15_Pin, GPIO_PIN_SET); // 设置失败信号
        /* 循环测试整体测试失败 */
    }
}

/**
 * 锁定循环函数
 *
 * 该函数旨在根据当前锁定状态执行特定的循环操作，并对操作结果进行处理。
 * 它首先检查当前的循环阶段是否在有效范围内，如果是，则执行相应阶段的循环应用。
 * 接着，对循环阶段的结果进行判断处理。最后，根据整个循环过程的结果进行相关的处理。
 *
 * 注意：此函数的实现依赖于全局变量lock_data及其状态，以及预定义的循环处理逻辑。
 */
void lock_loop(void)
{
    Rt_result result = TEST_WAIT; // 初始化结果变量为等待测试状态

    // 检查当前循环阶段是否在有效范围内，如果是，则执行该阶段的循环应用
    if (LOOP_NOT_MAX > lock_data.t_st)
    {
        result = Ehbl_loop[lock_data.t_st].loop_app();
    }

    // 对当前循环阶段的结果进行判断处理
    Loop_Stage_result_judgment(result, lock_data.t_st);

    // 获取整个循环过程的最终结果
    result = loop_results();

    // 根据整个循环过程的最终结果进行相应的处理
    loop_results_relevant(result);
}

/*
 * 函数名称: Loop_Start_button
 * 功能描述: 启动测试按键检测，用于检测启动测试的按键是否被按下，并处理按键事件。
 * 参数说明: 无
 * 返回值: 无
 * 备注: 使用了消抖技术来避免因按键抖动造成的误判。
 */
void Loop_Start_button(void)
{
    // 定义一个静态变量，用于计数去抖动时间
    volatile static unsigned int start_debounceCounter = 0;
    // 检测按键是否被按下
    if (LOOP_NOT_MAX == lock_data.t_st && ((0 == RTE_GPIO_PIN_GET_LEVEL(GPIOA, START1_TEST_I_PA15_Pin) || 0 == RTE_GPIO_PIN_GET_LEVEL(GPIOA, START2_TEST_I_PA9_Pin))))
    {
        // 如果之前按键是稳定的（未按下状态）
        if (true == lock_data.start_keyStableState)
        {                                            // 按键状态由稳定变为不稳定，记录按键按下时间
            start_debounceCounter = RTE_GET_TIMER(); // 记录当前时间作为按键按下时间的起点
            lock_data.start_keyStableState = false;  // 更新按键状态为不稳定
        }
        else if (yes_timeout == RTE_TIMEOUT_JUDGMENT(start_debounceCounter, DEBOUNCE_TIME_MS))
        {
            // 按键按下处理逻辑，包括设置GPIO状态等
            RTE_GPIO_PIN_SET_LEVEL(GPIOD, OUT8_PD15_Pin, GPIO_PIN_RESET);
            RTE_GPIO_PIN_SET_LEVEL(GPIOC, OUT7_PC6_Pin, GPIO_PIN_RESET);
            RTE_GPIO_PIN_SET_LEVEL(GPIOC, OverCurCtr_O_LL_PC13_Pin, GPIO_PIN_SET); /*产品上电*/
            RTE_GPIO_PIN_SET_LEVEL(GPIOE, Short_CTRL_PE5_Pin, GPIO_PIN_SET);
            RTE_HAL_DELAY(100);
            // RTE_EHBL_UART_TRANSMIT(UNLOCK_TEST_CMD,EHBL_UNLOCK_REQUEST_DATA);
            // RTE_HAL_DELAY(1000);
            //  按键持续按下时间超过消抖时间，确认按键按下事件
            lock_data.t_st = LOOP_INIT;
            // 重置按键状态为稳定（未按下），等待下一次按键事件
            lock_data.start_keyStableState = true;
            // lock_data.time_3s = RTE_GET_TIMER(); /*记录第一次3s循环开始时间*/
            RTE_UART7_LCD_SHOW(EHBL_LOOP_TEST, INTERFACE_SWITCH, 0x00000000);
        }
    }
}

/**
 * 主循环锁定函数
 * 该函数用于初始化手动重置检测、启动循环开始按钮，并持续进入锁定循环，以保持系统的持续运行。
 *
 * @param 无
 * @return 无
 */
void lock_loop_main(void)
{
    // 初始化手动重置检测机制，用于检测并处理系统的手动重置事件
    Manual_reset_detection();
    // 启动循环开始按钮，准备进入主循环
    Loop_Start_button();
    // 启动UART通信，用于与外部设备进行通信
    RTE_UART_MAIN();
    // 进入锁定循环，该循环将不断运行，直到系统被手动重置或遇到其他停止条件
    lock_loop();
}
